home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / system-config-printer / options.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-28  |  12.7 KB  |  389 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import gtk
  5.  
  6. def OptionWidget(name, v, s, on_change):
  7.     if isinstance(v, list):
  8.         if isinstance(s, list):
  9.             for vv in v + s:
  10.                 if not isinstance(vv, str):
  11.                     raise ValueError
  12.                 isinstance(vv, str)
  13.             
  14.             return OptionSelectMany(name, v, s, on_change)
  15.         print v, s
  16.         raise NotImplemented
  17.     isinstance(v, list)
  18.     if (isinstance(s, int) and isinstance(s, float) or isinstance(s, tuple)) and len(s) == 2:
  19.         if (isinstance(s[0], int) or isinstance(s[1], int) or isinstance(s[0], float)) and isinstance(s[1], float):
  20.             
  21.             try:
  22.                 if (isinstance(s, int) or isinstance(s, tuple)) and isinstance(s[0], int):
  23.                     v = int(v)
  24.                 else:
  25.                     v = float(v)
  26.             except ValueError:
  27.                 return OptionText(name, v, '', on_change)
  28.  
  29.             return OptionNumeric(name, v, s, on_change)
  30.         if isinstance(s, list):
  31.             for sv in s:
  32.                 if not isinstance(sv, int):
  33.                     return OptionSelectOne(name, v, s, on_change)
  34.             
  35.             
  36.             try:
  37.                 v = int(v)
  38.             except ValueError:
  39.                 isinstance(sv, int)
  40.                 isinstance(sv, int)
  41.                 isinstance(s[1], float)
  42.                 return OptionSelectOne(name, v, s, on_change)
  43.  
  44.             return OptionSelectOneNumber(name, v, s, on_change)
  45.         if isinstance(s, str):
  46.             return OptionText(name, v, s, on_change)
  47.         raise ValueError
  48.     return len(s) == 2
  49.  
  50.  
  51. class OptionInterface:
  52.     
  53.     def get_current_value(self):
  54.         raise NotImplemented
  55.  
  56.     
  57.     def is_changed(self):
  58.         raise NotImplemented
  59.  
  60.  
  61.  
  62. class OptionAlwaysShown(OptionInterface):
  63.     STATE_UNCHANGED = 0
  64.     STATE_RESET = 1
  65.     STATE_ADJUSTED = 2
  66.     
  67.     def __init__(self, name, ipp_type, system_default, widget, button, combobox_map = None, use_supported = False):
  68.         self.name = name
  69.         self.widget = widget
  70.         self.button = button
  71.         if ipp_type == bool:
  72.             
  73.             def bool_type(x):
  74.                 if type(x) == str:
  75.                     if x.lower() in ('false', 'no', 'off'):
  76.                         return False
  77.                     return True
  78.                 return bool(x)
  79.  
  80.             ipp_type = bool_type
  81.         
  82.         self.ipp_type = ipp_type
  83.         self.set_default(system_default)
  84.         self.combobox_map = combobox_map
  85.         if combobox_map != None and ipp_type == int:
  86.             model = self.widget.get_model()
  87.             i = 0
  88.             dict = { }
  89.             iter = model.get_iter_first()
  90.             while iter:
  91.                 dict[combobox_map[i]] = model.get_value(iter, 0)
  92.                 i += 1
  93.                 iter = model.iter_next(iter)
  94.             self.combobox_dict = dict
  95.         
  96.         self.use_supported = use_supported
  97.         self.reinit(None)
  98.  
  99.     
  100.     def set_default(self, system_default):
  101.         self.system_default = self.ipp_type(system_default)
  102.  
  103.     
  104.     def reinit(self, original_value, supported = None):
  105.         '''Set the original value of the option and the supported choices.
  106.         The special value None for original_value resets the option to the
  107.         system default.'''
  108.         if supported != None and self.use_supported:
  109.             if type(self.widget) == gtk.ComboBox and self.ipp_type == str:
  110.                 model = self.widget.get_model()
  111.                 model.clear()
  112.                 for each in supported:
  113.                     iter = model.append()
  114.                     model.set_value(iter, 0, each)
  115.                 
  116.             elif type(self.widget) == gtk.ComboBox and self.ipp_type == int and self.combobox_map != None:
  117.                 model = self.widget.get_model()
  118.                 model.clear()
  119.                 for each in supported:
  120.                     iter = model.append()
  121.                     model.set_value(iter, 0, self.combobox_dict[each])
  122.                 
  123.             
  124.         
  125.         if original_value != None:
  126.             self.original_value = self.ipp_type(original_value)
  127.             self.set_widget_value(self.original_value)
  128.             self.button.set_sensitive(True)
  129.         else:
  130.             self.original_value = None
  131.             self.set_widget_value(self.system_default)
  132.             self.button.set_sensitive(False)
  133.         self.state = self.STATE_UNCHANGED
  134.  
  135.     
  136.     def set_widget_value(self, ipp_value):
  137.         t = type(self.widget)
  138.         if t == gtk.SpinButton:
  139.             return self.widget.set_value(ipp_value)
  140.         if t == gtk.ComboBox:
  141.             if self.ipp_type == str and self.combobox_map == None:
  142.                 model = self.widget.get_model()
  143.                 iter = model.get_iter_first()
  144.                 while iter != None and model.get_value(iter, 0) != ipp_value:
  145.                     iter = model.iter_next(iter)
  146.                     continue
  147.                     t == gtk.SpinButton
  148.                 if iter:
  149.                     self.widget.set_active_iter(iter)
  150.                 
  151.             elif self.combobox_map:
  152.                 index = self.combobox_map.index(ipp_value)
  153.             else:
  154.                 index = ipp_value
  155.             return self.widget.set_active(index)
  156.         t == gtk.ComboBox
  157.         if t == gtk.CheckButton:
  158.             return self.widget.set_active(ipp_value)
  159.         raise NotImplemented
  160.  
  161.     
  162.     def get_widget_value(self):
  163.         t = type(self.widget)
  164.         if t == gtk.SpinButton:
  165.             
  166.             try:
  167.                 return self.ipp_type(self.widget.get_text())
  168.             except ValueError:
  169.                 return self.ipp_type(self.widget.get_value())
  170.             
  171.  
  172.         None<EXCEPTION MATCH>ValueError
  173.         if t == gtk.ComboBox:
  174.             if self.combobox_map:
  175.                 return self.combobox_map[self.widget.get_active()]
  176.             if self.ipp_type == str:
  177.                 return self.widget.get_active_text()
  178.             return self.ipp_type(self.widget.get_active())
  179.         if t == gtk.CheckButton:
  180.             return self.ipp_type(self.widget.get_active())
  181.         print t
  182.         raise NotImplemented
  183.  
  184.     
  185.     def get_current_value(self):
  186.         return self.get_widget_value()
  187.  
  188.     
  189.     def is_changed(self):
  190.         if self.original_value != None:
  191.             if self.state == self.STATE_RESET:
  192.                 return True
  193.             if self.state == self.STATE_ADJUSTED:
  194.                 if self.get_current_value() != self.original_value:
  195.                     return True
  196.                 return False
  197.             return False
  198.         if self.state == self.STATE_ADJUSTED:
  199.             return True
  200.         return False
  201.  
  202.     
  203.     def reset(self):
  204.         self.set_widget_value(self.system_default)
  205.         self.state = self.STATE_RESET
  206.         self.button.set_sensitive(False)
  207.  
  208.     
  209.     def changed(self):
  210.         self.state = self.STATE_ADJUSTED
  211.         self.button.set_sensitive(True)
  212.  
  213.  
  214.  
  215. class OptionAlwaysShownSpecial(OptionAlwaysShown):
  216.     
  217.     def __init__(self, name, ipp_type, system_default, widget, button, combobox_map = None, use_supported = False, special_choice = 'System default'):
  218.         self.special_choice = special_choice
  219.         self.special_choice_shown = False
  220.         OptionAlwaysShown.__init__(self, name, ipp_type, system_default, widget, button, combobox_map = combobox_map, use_supported = use_supported)
  221.  
  222.     
  223.     def show_special_choice(self):
  224.         if self.special_choice_shown:
  225.             return None
  226.         self.special_choice_shown = True
  227.         model = self.widget.get_model()
  228.         iter = model.insert(0)
  229.         model.set_value(iter, 0, self.special_choice)
  230.         self.widget.set_active_iter(model.get_iter_first())
  231.  
  232.     
  233.     def hide_special_choice(self):
  234.         if not self.special_choice_shown:
  235.             return None
  236.         self.special_choice_shown = False
  237.         model = self.widget.get_model()
  238.         model.remove(model.get_iter_first())
  239.  
  240.     
  241.     def reinit(self, original_value, supported = None):
  242.         if original_value != None:
  243.             self.hide_special_choice()
  244.         else:
  245.             self.show_special_choice()
  246.         OptionAlwaysShown.reinit(self, original_value, supported = supported)
  247.  
  248.     
  249.     def reset(self):
  250.         self.show_special_choice()
  251.         OptionAlwaysShown.reset(self)
  252.  
  253.     
  254.     def changed(self):
  255.         OptionAlwaysShown.changed(self)
  256.         if self.widget.get_active() > 0:
  257.             self.hide_special_choice()
  258.         
  259.  
  260.  
  261.  
  262. class Option(OptionInterface):
  263.     conflicts = None
  264.     
  265.     def __init__(self, name, value, supported, on_change):
  266.         self.name = name
  267.         self.value = value
  268.         self.supported = supported
  269.         self.on_change = on_change
  270.         self.is_new = False
  271.         label = name
  272.         if not label.endswith(':'):
  273.             label += ':'
  274.         
  275.         self.label = gtk.Label(label)
  276.         self.label.set_alignment(0, 0.5)
  277.  
  278.     
  279.     def get_current_value(self):
  280.         raise NotImplemented
  281.  
  282.     
  283.     def is_changed(self):
  284.         if not self.is_new:
  285.             pass
  286.         return str(self.get_current_value()) != str(self.value)
  287.  
  288.     
  289.     def changed(self, widget, *args):
  290.         self.on_change(self)
  291.  
  292.  
  293.  
  294. class OptionSelectOne(Option):
  295.     
  296.     def __init__(self, name, value, supported, on_change):
  297.         Option.__init__(self, name, value, supported, on_change)
  298.         self.selector = gtk.combo_box_new_text()
  299.         selected = None
  300.         for nr, choice in enumerate(supported):
  301.             self.selector.append_text(str(choice))
  302.             if str(value) == str(choice):
  303.                 selected = nr
  304.                 continue
  305.         
  306.         if selected is not None:
  307.             self.selector.set_active(selected)
  308.         else:
  309.             print 'Unknown value for %s: %s' % (name, value)
  310.             print 'Choices:', supported
  311.         self.selector.connect('changed', self.changed)
  312.  
  313.     
  314.     def get_current_value(self):
  315.         return self.selector.get_active_text()
  316.  
  317.  
  318.  
  319. class OptionSelectOneNumber(OptionSelectOne):
  320.     
  321.     def get_current_value(self):
  322.         return int(self.selector.get_active_text())
  323.  
  324.  
  325.  
  326. class OptionSelectMany(Option):
  327.     
  328.     def __init__(self, name, value, supported, on_change):
  329.         Option.__init__(self, name, value, supported, on_change)
  330.         self.checkboxes = []
  331.         vbox = gtk.VBox()
  332.         for s in supported:
  333.             checkbox = gtk.CheckButton(label = s)
  334.             checkbox.set_active(s in value)
  335.             vbox.add(checkbox)
  336.             checkbox.connect('toggled', self.changed)
  337.             self.checkboxes.append(checkbox)
  338.         
  339.         self.selector = vbox
  340.  
  341.     
  342.     def get_current_value(self):
  343.         return _[1]
  344.  
  345.  
  346.  
  347. class OptionNumeric(Option):
  348.     
  349.     def __init__(self, name, value, supported, on_change):
  350.         if isinstance(supported, float) and isinstance(supported, tuple):
  351.             pass
  352.         self.is_float = isinstance(supported[0], float)
  353.         if self.is_float:
  354.             digits = 2
  355.         else:
  356.             digits = 0
  357.         if not isinstance(supported, tuple):
  358.             supported = (0, supported)
  359.         
  360.         Option.__init__(self, name, value, supported, on_change)
  361.         adj = gtk.Adjustment(value, supported[0], supported[1], 1, 5, 0)
  362.         self.selector = gtk.SpinButton(adj, climb_rate = 1, digits = digits)
  363.         if not self.is_float:
  364.             self.selector.set_numeric(True)
  365.         
  366.         self.selector.connect('changed', self.changed)
  367.  
  368.     
  369.     def get_current_value(self):
  370.         if self.is_float:
  371.             return self.selector.get_value()
  372.         return self.selector.get_value_as_int()
  373.  
  374.  
  375.  
  376. class OptionText(Option):
  377.     
  378.     def __init__(self, name, value, supported, on_change):
  379.         Option.__init__(self, name, value, supported, on_change)
  380.         self.selector = gtk.Entry()
  381.         self.selector.set_text(value)
  382.         self.selector.connect('changed', self.changed)
  383.  
  384.     
  385.     def get_current_value(self):
  386.         return self.selector.get_text()
  387.  
  388.  
  389.